#include "TADPersona.h"

#include <stdio.h>
#include <conio.h>
#include <string.h>

void PedirPersona(Persona VP[],int posM)
{
   int ban=0;

   VP[posM].EsTrabDir=0;
		
   VP[posM].NomPersona = PedirNombre();
   
   VP[posM].DNI = PedirNIF();
   
   printf("\nIntroduzca Edad: ");
   flushall();
   scanf("%hu",&VP[posM].Edad);

	printf("\nIndique con un 1 si la persona es Trabajador o 2 si la persona es un Directivo: ");
   
	while (ban == 0)
   {

		scanf ("%i",&VP[posM].EsTrabDir);

	
		if (VP[posM].EsTrabDir==1 || VP[posM].EsTrabDir==2)
		{
			ban =1;	
		}
	
	}
	
	VP[posM].DatosOcup = PedirOcup(VP[posM].EsTrabDir);
   
	VP[posM].DiTo=pedirDatos();
}

/*
Persona GenerarPersona (Nombre N,NIF D,unsigned short E,Ocup O, int Tipo)
{
   Persona P;

   P.NomPersona = N;
   copiaNIF(&P.DNI,D);
   P.Edad= E;
   P.EsTrabDir = Tipo;
   P.DatosOcup = CrearOcup(Tipo,O.EsTra,O.EsDirec);
  // P.DiTo=generarDatos(P.DiTo,int CP,char siti)
   return(P);
}
*/

void VisualizaPersona(Persona P[],int posicion)
{

	if (posicion != -1)
	{
		VisualizaNombre(P[posicion].NomPersona);
		verNIF(P[posicion].DNI);
		printf("\nEdad: %hu",P[posicion].Edad);
		PintarOcup(P[posicion].EsTrabDir,P[posicion].DatosOcup);
		visualizarDatos(P[posicion].DiTo);
	}
	else
	{
		printf("\nEl NIF introducido, no esta registrado. \n");
	
	}
}


int CompararPersona (Persona P1, Persona P2)
{
	return(comprovarNIF(P1.DNI,P2.DNI));

}

void modificarP (Persona P[],int posicion)
{
	int ban=0;
	int ban2=0;
	int op=0;
	int pos=0;
	

	printf("\n\nDatos de la persona a modificar:\n");
	VisualizaPersona(P,posicion);

	while (ban == 0 )
	{
		printf("\n\nSeleccione una opcion:\n[1] Modificar el nombre\n[2] Modificar el NIF\n[3] Modificar su edad\n[4] Modificar su ocupacion\n[5] Volver al menu principal\n");
		scanf("%int",&op);
		
		switch (op)
		{
		
		case 1:
			modificarN (&(P[posicion].NomPersona));
			break;
		
	  case 2:
			modificarNIF(&P[posicion].DNI);
			break;
		
		case 3:
			printf("\nIntroduzca la nueva edad de la persona: ");
			flushall();
			scanf("%hu",&P[posicion].Edad);
			break;
		
		case 4:
			printf("\nIntroduzca su nueva ocupacion:\n");
			printf("    [1] Trabajador.\n");
			printf("    [2] Directivo. \n");
			
			while (ban2==0)
			{
				flushall();
				scanf("%i",&P[posicion].EsTrabDir);
				
				if (P[posicion].EsTrabDir==1 || P[posicion].EsTrabDir==2)
				{
					ban2=1;	
				}
	
			}

			modificarOcup(&P[posicion].DatosOcup,&P[posicion].EsTrabDir);

			break;

		case 5: 
			ban=1;
			break;
		}
	}

	printf("\nNuevos datos de la persona:\n");
	VisualizaPersona(P,posicion);

}

int buscarPersona (Persona VP[],int posMAX)
{
	unsigned long NIF=0;
	int posicion;
	int resultado=-1;

	printf("\nIntroduzca el NIF de la persona a buscar: ");
	scanf("%lu",&NIF);



	for(posicion=0;((posicion<posMAX) && (resultado==-1));posicion++)
	{
		resultado=busNIF(VP[posicion].DNI,NIF);
		
		if(resultado==1)
		{
			resultado=posicion;	
		}
	}
	return(resultado);
}

/*
Procedimiento BurbujaGV2(E/S A es Vector [n]de Elem, Orden es Entero) 
	// Suponemos de 1 a n y Orden = 1 -> Creciente Orden = 2-> Decreciente 
	
	Var 
		i,j es Entero 
	fVar 
	
	Para i desde 1 hasta n-1 hacer	//las n-1 pasadas 
		Para j desde 1 hasta n-i hacer	//el recorrido 
			Si (CompararElem (A[j+1], A[j])= Orden) entonces Intercambiar( A[j] , A[j+1])/Se intercambian 
		
		   fSi 
		fPara 
	fPara 
fProcedimiento

*/

//Burbuja

void burbuja (Persona VP[],int posicion, int Orden)
{
	int cont1,cont2,opcion=0;

	for (cont1=0;cont1<posicion-1; cont1++)
	{
		for (cont2=0;cont2<posicion-cont1-1;cont2++)
		{
			if ((compararNIF (&VP[cont2].DNI,&VP[cont2+1].DNI)==Orden));
			{
				intercambiarPersona (&(VP[cont2]),&(VP[cont2+1]));
			}
		}
	}
}

// INSERCION DIRECTA

void inserciondir (Persona VO[], int pos, int Orden)
{
	int cont1,cont2;

	Persona cont3;

	for(cont1=1;cont1<pos;cont1++)
	{
		
		copiaNIF (&cont3.DNI,VO[cont1].DNI); //cont3=VO[cont1];
		cont2=cont1-1;
	
		while ((cont2>=0) && (compararNIF(&VO[cont2].DNI,&cont3.DNI)==Orden))
		{
			intercambiarPersona (&(VO[cont2+1]),&(VO[cont2])); //A[j+1]=A[j]
			cont2--;
		}

		copiaNIF (&(VO[cont2+1].DNI),cont3.DNI);//VO[cont2+1]=cont3;
	}
}


//SELECCION

void seleccion (Persona P[], int posMax, int Orden)
{

	int cont1,cont2,aux=0,posMin;

	for (cont1=0;cont1<posMax-1;cont1++)
	{
		posMin=cont1;

		for (cont2=cont1+1;cont2<posMax;cont2++)
		{
			
			//evaluamos si P[cont2] .DNI es menor que P[posMin] 

			if ((compararNIF (&P[posMin].DNI,&P[cont2].DNI))==Orden)
			{
				posMin=cont2;
			}		
		}

		/*
		corremos la posicion minima a P[cont1].DNI, haciendo que
		P[cont1].DNI se mueva una posicion hacia la derecha.	
		*/

		intercambiarPersona (&(P[cont1]),&(P[posMin]));

	}

}


void listarNIF(Persona P[], int posM)
{
	int posicion;


	for (posicion=0;posicion<posM;posicion++)
	{
		verNIF(P[posicion].DNI);		
	
	}

	printf ("\n");
}

void intercambiarPersona (Persona *P1, Persona *P2)
{
	Persona PersonaAux1,*PersonaAux2;
	
	PersonaAux1=*P1;
	*P1=*P2;
	*P2=PersonaAux1;

}


void escribirFich (Persona P, FILE *locfichero)
{
	escribirFichNIF (P.DNI,locfichero);
	
	escribirNomFich(P.NomPersona,locfichero);

	fprintf(locfichero,":%hu:",P.Edad);
	
	fprintf(locfichero,"%i:",P.EsTrabDir);
	
	escribirOcupFich(P.DatosOcup,P.EsTrabDir,locfichero);
	
	escribirFichDirT(P.DiTo, locfichero);

	fprintf(locfichero,"\n");
}


void datosPerFich (Persona *P,FILE *dir)
{
	datosNIFFich(&P->DNI,dir);
	
	datosNomFich(&P->NomPersona,dir);

	fscanf(dir," :%hu:",&P->Edad);
	
	fscanf(dir,"%i:",&P->EsTrabDir);

	datosOcupFich(&P->DatosOcup,P->EsTrabDir,dir);

	datosDirTFich(&P->DiTo,dir);

}
